# -*- coding:utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
sys.path.append("..")
import settings
from datetime import date, datetime
import time
import logging
import logging.config
import settings
import utils_database
import usefulTools
# from PO import BasePage
import copy

"""

"""

dlmis = "dlmis" if settings.dbTypeName == "oracle" else ""
dlhist = "dlhist" if settings.dbTypeName == "oracle" else ""
dlsys = "dlsys" if settings.dbTypeName == "oracle" else ""
umstat = "umstat" if settings.dbTypeName == "oracle" else ""
dlmis_ = "dlmis." if settings.dbTypeName == "oracle" else ""
dlhist_ = "dlhist." if settings.dbTypeName == "oracle" else ""
dlsys_ = "dlsys." if settings.dbTypeName == "oracle" else ""
umstat_ = "umstat." if settings.dbTypeName == "oracle" else ""

usefulTools_instances = usefulTools.userfulToolsFactory()

# timestr = time.strftime('%Y%m%d', time.localtime(time.time()))
timestr = time.strftime('%Y%m', time.localtime(time.time()))
event_desc = "web auto test rec - " + timestr + "%"
print event_desc

class database_operate():
    #获取授权相关的案件列表
    def get_rec_infor_by_menuType(self,menu_type,act_property_id=None,human_id = None):
        #从rec表获取中获取当日上报的案件
        if act_property_id:
            rec_infor_sql = 'select t.rec_id,t.task_num,t.act_property_id from %(dlmis)sto_rec t,%(dlmis)sto_rec_act a where act_property_id in %(act_property_id)s and t.rec_id = a.rec_id and a.human_id in (0,%(human_id)s)'
            # rec_infor_sql = 'select t.rec_id,t.task_num,t.act_property_id from %(dlmis)sto_rec t,%(dlmis)sto_rec_act a where act_property_id in %(act_property_id)s and t.rec_id = a.rec_id'
            param = {'act_property_id': act_property_id,'human_id':human_id, 'dlmis': dlmis_,'event_desc':'\''+event_desc+'\''}
            rec_id_list = utils_database.data_seach_by_sql(rec_infor_sql % param)
        else:
            rec_sql = 'select rec_id,task_num,act_property_id from ' + dlmis_ + "to_rec where event_desc like '" + event_desc + "\'"
            rec_id_list = utils_database.data_seach_by_sql(rec_sql)
        if len(rec_id_list) > 0:
            # print rec_id_list[0][0]
            #根据rec_id获取role_id
            for id in range(len(rec_id_list)):
                #从rec_act 表获取item_menu_set的内容，并把内容进行处理
                item_menu_set_sql = 'select item_menu_set from ' + dlmis_ + "to_rec_act where rec_id = " + str(rec_id_list[id][0])
                item_menu_set = utils_database.data_seach_by_sql(item_menu_set_sql)
                print item_menu_set
                #比对item_menu_set的内容是否包含 申请授权的菜单
                if usefulTools_instances.accredit_status_check(item_menu_set,menu_type):
                    # print str(rec_id_list[id][0]) + u' 在授权阶段'
                    rec_infor = [rec_id_list[id][0],rec_id_list[id][1],rec_id_list[id][2]]
                    print rec_infor
                    return rec_infor
        else:
            return 0

    def get_recInfor_by_taskNum(self,task_num):
        #根据task_num获取案件信息
        print u'根据task_num获取案件信息,task_num = '+str(task_num)
        rec_infor_sql = 'select rec_id,task_num,act_property_id from %(dlmis)sto_rec where task_num = %(task_num)s'
        param = {'task_num': task_num, 'dlmis': dlmis_}
        rec_infor = utils_database.data_seach_by_sql(rec_infor_sql %param)
        return rec_infor[0]

    #根据案件act表获取当前案件所在的阶段用户信息
    def get_human_infor_by_recid(self,rec_id):
        # role_id_sql = 'select role_id from ' + dlmis + ".to_rec_act where rec_id = " + str(rec_id)
        # human_list_sql = 'select a.role_id,c.human_id,c.user_name from ' + dlmis_ + "to_rec_act a," + dlsys_ + 'tc_human_role b,'+ dlsys_ + 'tc_human c ' + 'where a.role_id = b.role_id and b.human_id = c.human_id and a.rec_id = ' + str(rec_id)
        human_list_sql = 'select a.role_id,c.human_code,c.user_name,a.human_id,a.human_name,c.human_id from ' + dlmis_ + "to_rec_act a," + dlsys_ + 'tc_human_role b,'+ dlsys_ + 'tc_human c ' + 'where a.role_id = b.role_id and b.human_id = c.human_id and a.rec_id = ' + str(rec_id)
        human_list = utils_database.data_seach_by_sql(human_list_sql)
        print human_list
        return human_list

    #根据用户的user_name获取用户的基础信息
    def get_human_infor_by_username(self,user_name):
        # human_infor_sql = 'select t.human_id,t.human_name,t.user_name,t.human_code from dlsys.tc_human t where t.user_name = \'' + user_name +'\''
        human_infor_sql = 'select t.human_id,t.human_name,t.user_name,t.human_code from %(dlsys)stc_human t where t.user_name = %(user_name)s'
        param = {'user_name':'\''+user_name+'\'','dlsys':dlsys_}
        print human_infor_sql %param
        human_infor = utils_database.data_seach_by_sql(human_infor_sql %param)
        # human_infor = utils_database.data_seach_by_sql(human_infor_sql)
        return human_infor

    #更新nav_item表，设置desktop_left，以使desktop上有相关需要测试的菜单
    def update_nav_item(self,desktop_left,desktop_top,human_id,nav_item_id):
        update_sql = 'update %(dlsys)stc_human_nav_item t set desktop_flag=1, desktop_left =%(desktop_left)s, desktop_top = %(desktop_top)s where t.human_id = %(human_id)s and t.nav_item_id = %(nav_item_id)s'
        param = {'desktop_top':desktop_top,'desktop_left':desktop_left,'human_id':human_id,'nav_item_id':nav_item_id,'dlsys':dlsys_}
        print update_sql %param
        utils_database.data_update_by_sql(update_sql %param)

    #清空nav_item表，设置desktop_left，都设置为0
    def update_nav_item_clear_desktop_flag(self,human_id):
        update_sql = 'update %(dlsys)stc_human_nav_item t set desktop_flag=0 where t.human_id = %(human_id)s '
        param = {'human_id':human_id,'dlsys':dlsys_}
        print update_sql %param
        utils_database.data_update_by_sql(update_sql %param)

    #根据用户ID 获取当前用户的task_list信息
    def get_tasklist_infor(self,human_id,task_list_group_id):
        task_list_sql = 'select t.task_list_id,t.task_list_name,t.display_name,t.count_sql,t.list_sql from %(dlsys)stc_human_task_list t where t.human_id = %(human_id)s and t.task_list_group_id = %(task_list_group_id)s'
        param = {'human_id':human_id,'task_list_group_id':task_list_group_id,'dlsys':dlsys_}
        task_list_infor = utils_database.data_seach_by_sql(task_list_sql %param)
        print len(task_list_infor)
        return task_list_infor

    #获取当前系统工作流的阶段信息
    def get_wf_act_def(self):
        wf_act_def_infor_sql = 'select t.act_def_id,t.act_def_name,t.act_property_id from %(dlsys)stc_wf_act_def t where t.proc_def_id = %(proc_def_id)s and t.proc_def_ver = 0 and t.act_property_id < 100'
        param = {'proc_def_id':settings.proc_def_id,'dlsys':dlsys_}
        print wf_act_def_infor_sql %param
        wf_act_def_infor = utils_database.data_seach_by_sql(wf_act_def_infor_sql %param)
        print wf_act_def_infor
        return wf_act_def_infor

    #根据当前的流向起始节点获取流向信息
    def get_wf_trans_def(self,from_act_def_id):
        wf_trans_def_infor_sql = 'select t.from_act_def_id,t.to_act_def_id,t.proc_def_id from %(dlsys)stc_wf_trans_def t where t.proc_def_id = %(proc_def_id)s and t.proc_def_ver = 0 and t.from_act_def_id =%(from_act_def_id)s and t.to_act_def_id in(select act_def_id from %(dlsys)stc_wf_act_def where proc_def_id = %(proc_def_id)s and proc_def_ver = 0 and act_property_id < 100)'
        param = {'proc_def_id': settings.proc_def_id,'from_act_def_id':from_act_def_id, 'dlsys': dlsys_}
        print wf_trans_def_infor_sql %param
        wf_trans_def_infor = utils_database.data_seach_by_sql(wf_trans_def_infor_sql %param)
        print wf_trans_def_infor
        return wf_trans_def_infor

database_operate_instances = database_operate()
#对基础的数据进行处理
class data_handle_operate():
    # 获取流程可能的组合
    def get_wf_process_group_num(self):
        print u'获取流向组合最大值'
        # 获取所有的流向
        wf_act_def_infor = database_operate_instances.get_wf_act_def()
        wf_process_group_num = 1
        for i in range(len(wf_act_def_infor)):
            next_def_list = database_operate_instances.get_wf_trans_def(wf_act_def_infor[i][0])
            if len(next_def_list) != 0:
                wf_process_group_num = wf_process_group_num * len(next_def_list)
        print u'流向的最大组合为：' + str(wf_process_group_num)
        return wf_process_group_num

    #整理 系统工作流的流程
    def arrange_wf_process(self):
        #获取当前工作流最大可能的流程数量
        wf_process_group_num = data_handle_operate.get_wf_process_group_num(data_handle_operate())

        #获取当前工作流节点信息
        wf_act_def_infor = database_operate_instances.get_wf_act_def()
        #定义部分列表变量
        wf_process_list_base = [] #临时存储copy当前阶段截止的流向
        wf_process_list = [] #存储所有的流向列表
        wf_process_list_all =[] #此变量暂时未使用
        act_multi_trans_list = [] #存储所有流向超过1的节点
        wf_act_strat_list = []  #存储起始节点的列表
        next_act_id = 0 #存储初始的 下个节点的id

        #根据act_property_id 获取工作流的起始节点，加入列表
        for i in range(len(wf_act_def_infor)):
            if wf_act_def_infor[i][2] == 1 or wf_act_def_infor[i][2] == 2:
                wf_process_list_base = wf_act_def_infor[i][0]
                print wf_process_list_base
                wf_act_strat_list.append(wf_process_list_base)
        print wf_act_strat_list
        print u'=====================开始节点打印=============='

        #根据起始节点开始获取流向，从第一个开始节点进行循环
        for process_list_id in range(len(wf_act_strat_list)):
            #获取到第一个开始节点，并加入到流向中
            wf_process_base = [wf_act_strat_list[process_list_id]]
            #因为需要使用while循环，需要先定义起始的的act_def_list 的id
            act_def_list_id = 0
            #根据系统所有的节点列表进行循环
            while act_def_list_id <= len(wf_act_def_infor):
            # for act_def_list_id in range(len(wf_act_def_infor)):
                #使用 act_def_list_id 做循环，每次循环 act_def_list_id + 1
                act_def_list_id = act_def_list_id + 1
                #获取下个当前阶段的流向列表
                next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[len(wf_process_base)-1])
                # wf_process_base.append(next_act_def[0][1])
                """
                根据流向的数量进行判断，如果流向数量=0，则说明为结束节点；直接将该节点加入到流向列表中
                如果流向中包含的节点已经在列表中，则说明该流向为核查未通过的节点，之前的流程已走过一轮，不再进行，直接加入流向列表
                """
                if len(next_act_def) ==0 or next_act_def[next_act_id][1] in wf_process_base:
                    if len(next_act_def) > 1 and next_act_def[next_act_id][1] in wf_process_base:
                        #获取当前多流向的 在流向列表中的位置 ID，并记录流向的数量
                        act_multi_trans_bak = []
                        #act_multi_trans 中的三个参数：1、当前多流向的节点在当前流向列表中的位置；2、当前节点的流向数量；3、当前节点循环次数（循环次数从0开始）
                        act_multi_trans = [len(wf_process_base), len(next_act_def), next_act_id]
                        #把流向的下个节点信息 加入到流向中
                        wf_process_base.append(next_act_def[next_act_id][1])
                        #判断当前的多流向的节点 第几次循环，如果循环次数小于 节点的流向数量，则把该节点及流向数量、当前循环次数加入到act_multi_trans_list中
                        if act_multi_trans[2] + 1 < act_multi_trans[1]:
                            act_multi_trans_bak = copy.deepcopy(act_multi_trans)
                            act_multi_trans_list.append(act_multi_trans_bak)
                        elif act_multi_trans_list[len(act_multi_trans_list) - 1][2] + 1 ==act_multi_trans_list[len(act_multi_trans_list) - 1][1]:
                            del act_multi_trans_list[len(act_multi_trans_list) - 1]
                            next_act_id = 0
                        # 如果当前的多流向的节点信息不加入多节点列表，则把下次循环的起始节点设置为0
                        else:
                            next_act_id = 0
                        # print act_multi_trans_list
                    #备份当前的流向信息到临时表--wf_process_base_bak，并将临时表加入整体的流向列表中--wf_process_list
                    wf_process_base_bak = []
                    wf_process_base_bak = copy.deepcopy(wf_process_base)
                    wf_process_list.append(wf_process_base_bak)
                    print wf_process_list
                    print u'==============第一个流向已获取完成==================='
                    print act_multi_trans_list
                    print u'==============阶段多流向记录==================='
                    """"
                    判断 多节点列表是否为空
                    为空：则直接退出循环，获取下个起始节点再进行获取
                    不为空：（for循环无法改变range的当前阶段的值）
                    1、获取当前多节点流向的最后一个节点，从节点中取出当前节点的 act_def_list_id，作为下次循环的起始节点（这就是为嘛不用for循环的原因）
                    2、计算 next_act_id值，根据当前的 next_act_def 循环次数 +1
                    3、修改act_multi_trans_list中的当前节点的循环次数
                    """
                    if len(act_multi_trans_list) > 0:
                        act_def_list_id =act_multi_trans_list[len(act_multi_trans_list)-1][0]
                        next_act_id = act_multi_trans_list[len(act_multi_trans_list)-1][2] + 1
                        act_multi_trans_list[len(act_multi_trans_list) - 1][2] = next_act_id
                        print act_multi_trans_list
                        print u'==============更新之后的---阶段多流向记录==================='
                    else:
                        break
                    # if next_act_id + 1 == act_multi_trans_list[len(act_multi_trans_list)-1][1]:
                    #     del act_multi_trans_list[len(act_multi_trans_list)-1]
                    #修改当前流向列表，从0 --最后一个多流向的节点，再次循环获取该节点的下个流向，并加入流向列表
                    wf_process_base = wf_process_base[0:int(act_def_list_id)]
                    continue
                #流向数量 =1 的情况下，直接把下个节点加入到流向列表
                elif len(next_act_def) ==1:
                    wf_process_base.append(next_act_def[0][1])
                else:
                    #获取当前多流向的 列表ID，并记录流向的数量

                    # wf_process_base_bak = copy.deepcopy(wf_process_base)
                    while next_act_id < len(next_act_def):
                    # for next_act_id in range(len(next_act_def)):
                        print 'next_act_id = ' + str(next_act_def[next_act_id][1])
                        # 获取当前多流向的 在流向列表中的位置 ID，并记录流向的数量
                        act_multi_trans_bak = []
                        # act_multi_trans 中的三个参数：1、当前多流向的节点在当前流向列表中的位置；2、当前节点的流向数量；3、当前节点循环次数（循环次数从0开始）
                        act_multi_trans = [len(wf_process_base), len(next_act_def), next_act_id]
                        print act_multi_trans
                        #根据节点流向 + next_act_id 获取本次的下个节点的信息，加入流向列表
                        wf_process_base.append(next_act_def[next_act_id][1])
                        print wf_process_base
                        print u'====================wf_process_base===================='
                        # 判断当前的多流向的节点 第几次循环，如果循环次数小于 节点的流向数量，则把该节点及流向数量、当前循环次数加入到act_multi_trans_list中
                        if act_multi_trans[2] + 1 < act_multi_trans[1]:
                            act_multi_trans_bak = copy.deepcopy(act_multi_trans)
                            act_multi_trans_list.append(act_multi_trans_bak)
                        #判断节点列表中的最后一个节点是否已循环执行完成。执行完成，则从act_multi_trans_list中删除该节点信息，并把节点流向起始节点设置为0
                        elif act_multi_trans_list[len(act_multi_trans_list) - 1][2] +1 ==act_multi_trans_list[len(act_multi_trans_list) - 1][1]:
                            del act_multi_trans_list[len(act_multi_trans_list) - 1]
                            next_act_id = 0
                        #如果当前的多流向的节点信息不加入多节点列表，则把下次循环的起始节点设置为0
                        else:
                            next_act_id = 0
                        print act_multi_trans_list
                        print u'====================act_multi_trans_list================'

                        break

            #             if act_def_list_id < len(wf_act_def_infor) -1:
            #                 for act_def_list_id_now in range(len(wf_act_def_infor) -act_def_list_id):
            #                     next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[len(wf_process_base) - 1])
            #                     if len(next_act_def) == 0:
            #                         continue
            #                     elif len(next_act_def) == 1:
            #                         wf_process_base.append(next_act_def[0][1])
            #                     else:
            #                         for next_act_id in range(len(next_act_def)):
            #                             print 'next_act_id = ' + str(next_act_def[next_act_id][1])
            #                             test = []
            #                             if next_act_id == 0:
            #                                 wf_process_base.append(next_act_def[next_act_id][1])
            #                                 test = copy.deepcopy(wf_process_base)
            #                             else:
            #                                wf_process_base[len(wf_process_base)-1] = next_act_def[next_act_id][1]
            #                                test = copy.deepcopy(wf_process_base)
            #                             print wf_process_base
            #                             print u'循环次数,当前节点:' + str(next_act_id) + u'整体循环节点：' + str(act_def_list_id)
            #                             wf_process_base_list.append(test)
            #                             print wf_process_base_list
            #                             print u'test====================================================================='
            #
            #             print wf_process_base_list
            #             print u'循环次数,当前节点:' + str(next_act_id) + u'整体循环节点：'+str(act_def_list_id)
            #             next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[act_def_list_id])
            #
            # print wf_process_base_list

        # for process_base_id in range(len(wf_process_base)):
        #     next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[process_base_id])
        #     if len(next_act_def) ==0 or len(next_act_def) ==1:
        #         continue
        #     else:

#整理 系统工作流的流程
            wf_process_list_all.append(wf_process_list)
            print u'所有的流向列表如下'
            print wf_process_list_all
            print wf_process_list_all[0][0]
            return wf_process_list_all
    def arrange_wf_process_bak(self):
        #获取当前工作流最大可能的流程数量
        wf_process_group_num = data_handle_operate.get_wf_process_group_num(data_handle_operate())

        #获取当前工作流节点信息
        wf_act_def_infor = database_operate_instances.get_wf_act_def()
        wf_process_list_base = []
        wf_process_list = []
        wf_process_base_list =[]

        #根据act_property_id 获取工作流的起始节点，加入列表
        for i in range(len(wf_act_def_infor)):
            if wf_act_def_infor[i][2] == 1 or wf_act_def_infor[i][2] == 2:
                wf_process_list_base = wf_act_def_infor[i][0]
                print wf_process_list_base
                wf_process_list.append(wf_process_list_base)
        print wf_process_list

        #根据起始节点开始获取流向
        for process_list_id in range(len(wf_process_list)):
            wf_process_base = [wf_process_list[process_list_id]]
            for act_def_list_id in range(len(wf_act_def_infor)):
                next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[len(wf_process_base)-1])
                # wf_process_base.append(next_act_def[0][1])
                if len(next_act_def) ==0:
                    continue
                elif len(next_act_def) ==1:
                    wf_process_base.append(next_act_def[0][1])
                else:
                    wf_process_base_bak = copy.deepcopy(wf_process_base)
                    for next_act_id in range(len(next_act_def)):
                        wf_process_base = copy.deepcopy(wf_process_base_bak)
                        print 'next_act_id = ' + str(next_act_def[next_act_id][1])
                        wf_process_base.append(next_act_def[next_act_id][1])
                        if act_def_list_id < len(wf_act_def_infor) -1:
                            for act_def_list_id_now in range(len(wf_act_def_infor) -act_def_list_id):
                                next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[len(wf_process_base) - 1])
                                if len(next_act_def) == 0:
                                    continue
                                elif len(next_act_def) == 1:
                                    wf_process_base.append(next_act_def[0][1])
                                    # wf_process_base_1 = copy.deepcopy(wf_process_base)
                                    # wf_process_base_list.append(wf_process_base_1)
                                    print wf_process_base_list
                                else:
                                    for next_act_id in range(len(next_act_def)):
                                        print 'next_act_id = ' + str(next_act_def[next_act_id][1])
                                        test = []
                                        if next_act_id == 0:
                                            wf_process_base.append(next_act_def[next_act_id][1])
                                            test = copy.deepcopy(wf_process_base)
                                        else:
                                           wf_process_base[len(wf_process_base)-1] = next_act_def[next_act_id][1]
                                           test = copy.deepcopy(wf_process_base)
                                        print wf_process_base
                                        print u'循环次数,当前节点:' + str(next_act_id) + u'整体循环节点：' + str(act_def_list_id)
                                        wf_process_base_list.append(test)
                                        print wf_process_base_list
                                        print u'test====================================================================='

                        print wf_process_base_list
                        print u'循环次数,当前节点:' + str(next_act_id) + u'整体循环节点：'+str(act_def_list_id)
                        next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[act_def_list_id])

            print wf_process_base_list

        # for process_base_id in range(len(wf_process_base)):
        #     next_act_def = database_operate_instances.get_wf_trans_def(wf_process_base[process_base_id])
        #     if len(next_act_def) ==0 or len(next_act_def) ==1:
        #         continue
        #     else:

if __name__ == '__main__':
    print "utils test"
    # sql = 'select human_name from tc_human where human_name like ' + "'%测试'"
    #
    # sql1 = "select human_name from tc_human where human_name like %(test)s"
    # param = {"test":'测试'}
    #
    # test2 = '%测试123'
    # sql2 = 'select human_name from tc_human where human_name like \"' + test2 +'\"'
    #
    # dlmis = "dlmis" if settings.dbTypeName == "oracle" else ""
    #
    # print sql1 % param
    # print sql
    # print sql2
    # print 'dlmis = ' + dlmis
    database_operate_instances = database_operate()
    recInfor = database_operate_instances.get_rec_infor_by_menuType('transit')
    human_infor = database_operate_instances.get_human_infor_by_recid(recInfor[0])
    print "recInfor = " + str(recInfor)
    # user_name = str(human_infor[2])
    # print human_infor[2].decode('unicode-escape')
    # use = user_name.encode('raw_unicode_escape')
    # print 'use = ' + use
    print str(human_infor[1][1]).decode('GBK').encode('UTF-8')
    str_human = usefulTools_instances.db_data_deal(human_infor[2])
    print str(str_human).decode('GBK').encode('UTF-8')
    print '\xca\xd0\xbd\xd3\xcf\xdf\xd4\xb10316'.decode('GBK').encode('UTF-8')
    name = str(str_human.decode('utf-8'))
    print name
